home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / Menus.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  11.2 KB  |  424 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Menus.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Menus;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __MENUS__}
  27. {$SETC __MENUS__ := 1}
  28.  
  29. {$I+}
  30. {$SETC MenusIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __MEMORY__}
  35. {$I Memory.p}
  36. {$ENDC}
  37. {    Types.p                                                        }
  38. {        ConditionalMacros.p                                        }
  39. {    MixedMode.p                                                    }
  40.  
  41. {$IFC UNDEFINED __QUICKDRAW__}
  42. {$I Quickdraw.p}
  43. {$ENDC}
  44. {    QuickdrawText.p                                                }
  45.  
  46. {$IFC UNDEFINED __EVENTS__}
  47. {$I Events.p}
  48. {$ENDC}
  49. {    OSUtils.p                                                    }
  50.  
  51. {$PUSH}
  52. {$ALIGN MAC68K}
  53. {$LibExport+}
  54.  
  55. CONST
  56.     noMark                        = 0;                            {mark symbol for MarkItem}
  57. { menu defProc messages }
  58.     mDrawMsg                    = 0;
  59.     mChooseMsg                    = 1;
  60.     mSizeMsg                    = 2;
  61.     mDrawItemMsg                = 4;
  62.     mCalcItemMsg                = 5;
  63.     textMenuProc                = 0;
  64.     hMenuCmd                    = 27;                            {itemCmd == 0x001B ==> hierarchical menu}
  65.     hierMenu                    = -1;                            {a hierarchical menu - for InsertMenu call}
  66.     mPopUpMsg                    = 3;                            {menu defProc messages - place yourself}
  67.     mctAllItems                    = -98;                            {search for all Items for the given ID}
  68.     mctLastIDIndic                = -99;                            {last color table entry has this in ID field}
  69.  
  70. {$IFC UNDEFINED STRICT_MENUS }
  71. {$SETC STRICT_MENUS := 0}
  72. {$ENDC}
  73. {$IFC STRICT_MENUS }
  74.     
  75. TYPE
  76.     MenuRef = Ptr;
  77.  
  78. {$ELSEC}
  79.  
  80. TYPE
  81.     MenuInfo = RECORD
  82.         menuID:                    INTEGER;
  83.         menuWidth:                INTEGER;
  84.         menuHeight:                INTEGER;
  85.         menuProc:                Handle;
  86.         enableFlags:            LONGINT;
  87.         menuData:                Str255;
  88.     END;
  89.     MenuPtr = ^MenuInfo;
  90.     MenuHandle = ^MenuPtr;
  91.  
  92.     MenuRef = MenuHandle;
  93.  
  94. {$ENDC}
  95.     MenuDefProcPtr = ProcPtr;  { PROCEDURE MenuDef(message: INTEGER; theMenu: MenuRef; VAR menuRect: Rect; hitPt: Point; VAR whichItem: INTEGER); }
  96.     MenuBarDefProcPtr = ProcPtr;  { FUNCTION MenuBarDef(selector: INTEGER; message: INTEGER; parameter1: INTEGER; parameter2: LONGINT): LONGINT; }
  97.     MenuHookProcPtr = ProcPtr;  { PROCEDURE MenuHook; }
  98.     MBarHookProcPtr = ProcPtr;  { FUNCTION MBarHook(VAR menuRect: Rect): INTEGER; }
  99.     MenuDefUPP = UniversalProcPtr;
  100.     MenuBarDefUPP = UniversalProcPtr;
  101.     MenuHookUPP = UniversalProcPtr;
  102.     MBarHookUPP = UniversalProcPtr;
  103.  
  104. CONST
  105.     uppMenuDefProcInfo = $0000FF80; { PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param); }
  106.     uppMenuBarDefProcInfo = $00003AB0; { FUNCTION (2 byte param, 2 byte param, 2 byte param, 4 byte param): 4 byte result; }
  107.     uppMenuHookProcInfo = $00000000; { PROCEDURE ; }
  108.     uppMBarHookProcInfo = $000000CF; { SPECIAL_CASE_PROCINFO( kSpecialCaseMBarHook ) }
  109.  
  110. FUNCTION NewMenuDefProc(userRoutine: MenuDefProcPtr): MenuDefUPP;
  111.     {$IFC NOT GENERATINGCFM }
  112.     INLINE $2E9F;
  113.     {$ENDC}
  114.  
  115. FUNCTION NewMenuBarDefProc(userRoutine: MenuBarDefProcPtr): MenuBarDefUPP;
  116.     {$IFC NOT GENERATINGCFM }
  117.     INLINE $2E9F;
  118.     {$ENDC}
  119.  
  120. FUNCTION NewMenuHookProc(userRoutine: MenuHookProcPtr): MenuHookUPP;
  121.     {$IFC NOT GENERATINGCFM }
  122.     INLINE $2E9F;
  123.     {$ENDC}
  124.  
  125. FUNCTION NewMBarHookProc(userRoutine: MBarHookProcPtr): MBarHookUPP;
  126.     {$IFC NOT GENERATINGCFM }
  127.     INLINE $2E9F;
  128.     {$ENDC}
  129.  
  130. PROCEDURE CallMenuDefProc(message: INTEGER; theMenu: MenuRef; VAR menuRect: Rect; hitPt: Point; VAR whichItem: INTEGER; userRoutine: MenuDefUPP);
  131.     {$IFC NOT GENERATINGCFM}
  132.     INLINE $205F, $4E90;
  133.     {$ENDC}
  134.  
  135. FUNCTION CallMenuBarDefProc(selector: INTEGER; message: INTEGER; parameter1: INTEGER; parameter2: LONGINT; userRoutine: MenuBarDefUPP): LONGINT;
  136.     {$IFC NOT GENERATINGCFM}
  137.     INLINE $205F, $4E90;
  138.     {$ENDC}
  139.  
  140. PROCEDURE CallMenuHookProc(userRoutine: MenuHookUPP);
  141.     {$IFC NOT GENERATINGCFM}
  142.     INLINE $205F, $4E90;
  143.     {$ENDC}
  144.  
  145. FUNCTION CallMBarHookProc(VAR menuRect: Rect; userRoutine: MBarHookUPP): INTEGER;
  146.     {$IFC NOT GENERATINGCFM}
  147.     {To be implemented:  Glue to move parameters according to special case conventions.}
  148.     {$ENDC}
  149.  
  150. TYPE
  151.     MCEntry = RECORD
  152.         mctID:                    INTEGER;                                {menu ID.  ID = 0 is the menu bar}
  153.         mctItem:                INTEGER;                                {menu Item. Item = 0 is a title}
  154.         mctRGB1:                RGBColor;                                {usage depends on ID and Item}
  155.         mctRGB2:                RGBColor;                                {usage depends on ID and Item}
  156.         mctRGB3:                RGBColor;                                {usage depends on ID and Item}
  157.         mctRGB4:                RGBColor;                                {usage depends on ID and Item}
  158.         mctReserved:            INTEGER;                                {reserved for internal use}
  159.     END;
  160.     MCEntryPtr = ^MCEntry;
  161.  
  162.     MCTable = ARRAY [0..0] OF MCEntry;
  163.     MCTablePtr = ^MCEntry;
  164.     MCTableHandle = ^MCTablePtr;
  165.  
  166.     MenuCRsrc = RECORD
  167.         numEntries:                INTEGER;                                {number of entries}
  168.         mcEntryRecs:            MCTable;                                {ARRAY [1..numEntries] of MCEntry}
  169.     END;
  170.     MenuCRsrcPtr = ^MenuCRsrc;
  171.     MenuCRsrcHandle = ^MenuCRsrcPtr;
  172.  
  173. FUNCTION GetMBarHeight : INTEGER;
  174.     {$IFC NOT CFMSYSTEMCALLS}
  175.     INLINE $3EB8, $0BAA;            { MOVE.W $0BAA,(SP) }
  176.     {$ENDC}
  177.  
  178. PROCEDURE InitMenus;
  179.     {$IFC NOT GENERATINGCFM}
  180.     INLINE $A930;
  181.     {$ENDC}
  182. FUNCTION NewMenu(menuID: INTEGER; menuTitle: ConstStr255Param): MenuRef;
  183.     {$IFC NOT GENERATINGCFM}
  184.     INLINE $A931;
  185.     {$ENDC}
  186. FUNCTION GetMenu(resourceID: INTEGER): MenuRef;
  187.     {$IFC NOT GENERATINGCFM}
  188.     INLINE $A9BF;
  189.     {$ENDC}
  190. PROCEDURE DisposeMenu(theMenu: MenuRef);
  191.     {$IFC NOT GENERATINGCFM}
  192.     INLINE $A932;
  193.     {$ENDC}
  194. PROCEDURE AppendMenu(menu: MenuRef; data: ConstStr255Param);
  195.     {$IFC NOT GENERATINGCFM}
  196.     INLINE $A933;
  197.     {$ENDC}
  198. PROCEDURE AppendResMenu(theMenu: MenuRef; theType: ResType);
  199.     {$IFC NOT GENERATINGCFM}
  200.     INLINE $A94D;
  201.     {$ENDC}
  202. PROCEDURE InsertResMenu(theMenu: MenuRef; theType: ResType; afterItem: INTEGER);
  203.     {$IFC NOT GENERATINGCFM}
  204.     INLINE $A951;
  205.     {$ENDC}
  206. PROCEDURE InsertMenu(theMenu: MenuRef; beforeID: INTEGER);
  207.     {$IFC NOT GENERATINGCFM}
  208.     INLINE $A935;
  209.     {$ENDC}
  210. PROCEDURE DrawMenuBar;
  211.     {$IFC NOT GENERATINGCFM}
  212.     INLINE $A937;
  213.     {$ENDC}
  214. PROCEDURE InvalMenuBar;
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $A81D;
  217.     {$ENDC}
  218. PROCEDURE DeleteMenu(menuID: INTEGER);
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $A936;
  221.     {$ENDC}
  222. PROCEDURE ClearMenuBar;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $A934;
  225.     {$ENDC}
  226. FUNCTION GetNewMBar(menuBarID: INTEGER): Handle;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $A9C0;
  229.     {$ENDC}
  230. FUNCTION GetMenuBar: Handle;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $A93B;
  233.     {$ENDC}
  234. PROCEDURE SetMenuBar(menuList: Handle);
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $A93C;
  237.     {$ENDC}
  238. PROCEDURE InsertMenuItem(theMenu: MenuRef; itemString: ConstStr255Param; afterItem: INTEGER);
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $A826;
  241.     {$ENDC}
  242. PROCEDURE DeleteMenuItem(theMenu: MenuRef; item: INTEGER);
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $A952;
  245.     {$ENDC}
  246. FUNCTION MenuKey(ch: CHAR): LONGINT;
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $A93E;
  249.     {$ENDC}
  250. PROCEDURE HiliteMenu(menuID: INTEGER);
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $A938;
  253.     {$ENDC}
  254. PROCEDURE SetMenuItemText(theMenu: MenuRef; item: INTEGER; itemString: ConstStr255Param);
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $A947;
  257.     {$ENDC}
  258. PROCEDURE GetMenuItemText(theMenu: MenuRef; item: INTEGER; VAR itemString: Str255);
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $A946;
  261.     {$ENDC}
  262. PROCEDURE DisableItem(theMenu: MenuRef; item: INTEGER);
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $A93A;
  265.     {$ENDC}
  266. PROCEDURE EnableItem(theMenu: MenuRef; item: INTEGER);
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $A939;
  269.     {$ENDC}
  270. PROCEDURE CheckItem(theMenu: MenuRef; item: INTEGER; checked: BOOLEAN);
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $A945;
  273.     {$ENDC}
  274. PROCEDURE SetItemMark(theMenu: MenuRef; item: INTEGER; markChar: CHAR);
  275.     {$IFC NOT GENERATINGCFM}
  276.     INLINE $A944;
  277.     {$ENDC}
  278. PROCEDURE GetItemMark(theMenu: MenuRef; item: INTEGER; VAR markChar: CHAR);
  279.     {$IFC NOT GENERATINGCFM}
  280.     INLINE $A943;
  281.     {$ENDC}
  282. PROCEDURE SetItemIcon(theMenu: MenuRef; item: INTEGER; iconIndex: INTEGER);
  283.     {$IFC NOT GENERATINGCFM}
  284.     INLINE $A940;
  285.     {$ENDC}
  286. PROCEDURE GetItemIcon(theMenu: MenuRef; item: INTEGER; VAR iconIndex: Byte);
  287.     {$IFC NOT GENERATINGCFM}
  288.     INLINE $A93F;
  289.     {$ENDC}
  290. PROCEDURE SetItemStyle(theMenu: MenuRef; item: INTEGER; chStyle: Style);
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $A942;
  293.     {$ENDC}
  294. PROCEDURE GetItemStyle(theMenu: MenuRef; item: INTEGER; VAR chStyle: Style);
  295. PROCEDURE CalcMenuSize(theMenu: MenuRef);
  296.     {$IFC NOT GENERATINGCFM}
  297.     INLINE $A948;
  298.     {$ENDC}
  299. FUNCTION CountMItems(theMenu: MenuRef): INTEGER;
  300.     {$IFC NOT GENERATINGCFM}
  301.     INLINE $A950;
  302.     {$ENDC}
  303. FUNCTION GetMenuHandle(menuID: INTEGER): MenuRef;
  304.     {$IFC NOT GENERATINGCFM}
  305.     INLINE $A949;
  306.     {$ENDC}
  307. PROCEDURE FlashMenuBar(menuID: INTEGER);
  308.     {$IFC NOT GENERATINGCFM}
  309.     INLINE $A94C;
  310.     {$ENDC}
  311. PROCEDURE SetMenuFlash(count: INTEGER);
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $A94A;
  314.     {$ENDC}
  315. FUNCTION MenuSelect(startPt: Point): LONGINT;
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $A93D;
  318.     {$ENDC}
  319. PROCEDURE InitProcMenu(resID: INTEGER);
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $A808;
  322.     {$ENDC}
  323. PROCEDURE GetItemCmd(theMenu: MenuRef; item: INTEGER; VAR cmdChar: CHAR);
  324.     {$IFC NOT GENERATINGCFM}
  325.     INLINE $A84E;
  326.     {$ENDC}
  327. PROCEDURE SetItemCmd(theMenu: MenuRef; item: INTEGER; cmdChar: CHAR);
  328.     {$IFC NOT GENERATINGCFM}
  329.     INLINE $A84F;
  330.     {$ENDC}
  331. FUNCTION PopUpMenuSelect(menu: MenuRef; top: INTEGER; left: INTEGER; popUpItem: INTEGER): LONGINT;
  332.     {$IFC NOT GENERATINGCFM}
  333.     INLINE $A80B;
  334.     {$ENDC}
  335. FUNCTION MenuChoice: LONGINT;
  336.     {$IFC NOT GENERATINGCFM}
  337.     INLINE $AA66;
  338.     {$ENDC}
  339. PROCEDURE DeleteMCEntries(menuID: INTEGER; menuItem: INTEGER);
  340.     {$IFC NOT GENERATINGCFM}
  341.     INLINE $AA60;
  342.     {$ENDC}
  343. FUNCTION GetMCInfo: MCTableHandle;
  344.     {$IFC NOT GENERATINGCFM}
  345.     INLINE $AA61;
  346.     {$ENDC}
  347. PROCEDURE SetMCInfo(menuCTbl: MCTableHandle);
  348.     {$IFC NOT GENERATINGCFM}
  349.     INLINE $AA62;
  350.     {$ENDC}
  351. PROCEDURE DisposeMCInfo(menuCTbl: MCTableHandle);
  352.     {$IFC NOT GENERATINGCFM}
  353.     INLINE $AA63;
  354.     {$ENDC}
  355. FUNCTION GetMCEntry(menuID: INTEGER; menuItem: INTEGER): MCEntryPtr;
  356.     {$IFC NOT GENERATINGCFM}
  357.     INLINE $AA64;
  358.     {$ENDC}
  359. PROCEDURE SetMCEntries(numEntries: INTEGER; menuCEntries: MCTablePtr);
  360.     {$IFC NOT GENERATINGCFM}
  361.     INLINE $AA65;
  362.     {$ENDC}
  363. PROCEDURE InsertFontResMenu(theMenu: MenuRef; afterItem: INTEGER; scriptFilter: INTEGER);
  364.     {$IFC NOT GENERATINGCFM}
  365.     INLINE $303C, $0400, $A825;
  366.     {$ENDC}
  367. PROCEDURE InsertIntlResMenu(theMenu: MenuRef; theType: ResType; afterItem: INTEGER; scriptFilter: INTEGER);
  368.     {$IFC NOT GENERATINGCFM}
  369.     INLINE $303C, $0601, $A825;
  370.     {$ENDC}
  371. FUNCTION SystemEdit(editCmd: INTEGER): BOOLEAN;
  372.     {$IFC NOT GENERATINGCFM}
  373.     INLINE $A9C2;
  374.     {$ENDC}
  375. PROCEDURE SystemMenu(menuResult: LONGINT);
  376.     {$IFC NOT GENERATINGCFM}
  377.     INLINE $A9B5;
  378.     {$ENDC}
  379. {$IFC OLDROUTINENAMES }
  380. PROCEDURE AddResMenu(theMenu: MenuRef; theType: ResType);
  381.     {$IFC NOT GENERATINGCFM}
  382.     INLINE $A94D;
  383.     {$ENDC}
  384. PROCEDURE InsMenuItem(theMenu: MenuRef; itemString: ConstStr255Param; afterItem: INTEGER);
  385.     {$IFC NOT GENERATINGCFM}
  386.     INLINE $A826;
  387.     {$ENDC}
  388. PROCEDURE DelMenuItem(theMenu: MenuRef; item: INTEGER);
  389.     {$IFC NOT GENERATINGCFM}
  390.     INLINE $A952;
  391.     {$ENDC}
  392. PROCEDURE SetItem(theMenu: MenuRef; item: INTEGER; itemString: ConstStr255Param);
  393.     {$IFC NOT GENERATINGCFM}
  394.     INLINE $A947;
  395.     {$ENDC}
  396. PROCEDURE GetItem(theMenu: MenuRef; item: INTEGER; VAR itemString: Str255);
  397.     {$IFC NOT GENERATINGCFM}
  398.     INLINE $A946;
  399.     {$ENDC}
  400. FUNCTION GetMHandle(menuID: INTEGER): MenuRef;
  401.     {$IFC NOT GENERATINGCFM}
  402.     INLINE $A949;
  403.     {$ENDC}
  404. PROCEDURE DelMCEntries(menuID: INTEGER; menuItem: INTEGER);
  405.     {$IFC NOT GENERATINGCFM}
  406.     INLINE $AA60;
  407.     {$ENDC}
  408. PROCEDURE DispMCInfo(menuCTbl: MCTableHandle);
  409.     {$IFC NOT GENERATINGCFM}
  410.     INLINE $AA63;
  411.     {$ENDC}
  412. {$ENDC}
  413.  
  414. {$ALIGN RESET}
  415. {$POP}
  416.  
  417. {$SETC UsingIncludes := MenusIncludes}
  418.  
  419. {$ENDC} {__MENUS__}
  420.  
  421. {$IFC NOT UsingIncludes}
  422.  END.
  423. {$ENDC}
  424.